Creating and Processing Two-Dimensional Arrays in Java

Course: Core Java Training

Topic: Creating and Processing Two-Dimensional Arrays

Course Link: Core Java Training Course

Demo Link: Register for a Free Demo

JustAcademy Homepage: Visit JustAcademy

1. Introduction to Two-Dimensional Arrays

A two-dimensional array in Java is a data structure that organizes elements into rows and columns. It is useful when information naturally forms a table, such as student marks, sales figures, product prices, seating arrangements, and mathematical matrices.

Like a one-dimensional array, a two-dimensional array stores elements of a declared component type. Each element is accessed using two indexes: one for the row and another for the column. Java implements multidimensional arrays as arrays whose elements can themselves be arrays.

Example

int[][] numbers = {
    {10, 20, 30},
    {40, 50, 60},
    {70, 80, 90}
};

System.out.println(numbers[0][0]);
System.out.println(numbers[1][2]);
System.out.println(numbers[2][1]);

Output:

10
60
80

Here, numbers[0][0] accesses the first row's first element, while numbers[1][2] accesses the second row's third element.

2. Learning Objectives

• Understand the structure and purpose of two-dimensional arrays.
• Declare, create, and initialize two-dimensional arrays.
• Access and update elements using row and column indexes.
• Process array elements using nested loops.
• Calculate row totals, column totals, and overall sums.
• Understand rectangular and jagged arrays.
• Search, compare, and display two-dimensional array data.
• Identify common errors and apply appropriate debugging techniques.

3. Understanding Rows, Columns, and Indexes

A two-dimensional array can be visualized as a table. The first index identifies the row, and the second index identifies the element within that row.

Example Array

int[][] marks = {
    {75, 82, 91},
    {68, 79, 85},
    {90, 88, 95}
};

For example:

• marks[0][0] returns 75.
• marks[0][2] returns 91.
• marks[1][1] returns 79.
• marks[2][2] returns 95.

Java uses zero-based indexing for both dimensions. For a rectangular array with three rows and three columns, valid indexes are 0 through 2 in each dimension.

4. Declaring a Two-Dimensional Array

Before using an array, you can declare a variable that refers to a two-dimensional array. A declaration specifies the element type and the number of dimensions.

Syntax

dataType[][] arrayName;

Examples

int[][] matrix;
double[][] prices;
String[][] names;
char[][] letters;

These statements declare array variables. They do not yet create the row arrays or allocate storage for the elements.

5. Creating a Two-Dimensional Array

You can create a two-dimensional array using the new keyword. For a rectangular array, specify the number of rows and the number of columns in each row.

Syntax

dataType[][] arrayName = new dataType[rows][columns];

Example

int[][] matrix = new int[3][4];

This statement creates an array with three rows and four columns, providing twelve integer element positions. Each integer element is initialized to 0 by default.

6. Initializing a Two-Dimensional Array

Initialization means assigning initial values to the array elements. Java allows you to provide values directly in an array initializer.

Example: Direct Initialization

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

This creates a two-dimensional array with three rows and three columns.

Example: Creating First and Assigning Later

int[][] matrix = new int[2][3];

matrix[0][0] = 10;
matrix[0][1] = 20;
matrix[0][2] = 30;
matrix[1][0] = 40;
matrix[1][1] = 50;
matrix[1][2] = 60;

Use this approach when values become available after the array has been created, such as when reading input or processing data from another source.

7. Accessing Two-Dimensional Array Elements

Use two indexes inside square brackets to access a specific element.

Syntax

arrayName[rowIndex][columnIndex]

Example

public class AccessMatrix {
    public static void main(String[] args) {
        int[][] values = {
            {10, 20, 30},
            {40, 50, 60},
            {70, 80, 90}
        };

        System.out.println(values[0][1]);
        System.out.println(values[1][2]);
        System.out.println(values[2][0]);
    }
}

Output:

20
60
70

Remember that the first index represents the row and the second index represents the column.

8. Updating Two-Dimensional Array Elements

You can update an element by assigning a new value to its row and column position.

Syntax

arrayName[rowIndex][columnIndex] = newValue;

Example

public class UpdateMatrix {
    public static void main(String[] args) {
        int[][] numbers = {
            {1, 2, 3},
            {4, 5, 6}
        };

        numbers[0][1] = 99;
        numbers[1][2] = 100;

        System.out.println(numbers[0][1]);
        System.out.println(numbers[1][2]);
    }
}

Output:

99
100

The value at row 0, column 1 changes from 2 to 99. The value at row 1, column 2 changes from 6 to 100. All other elements remain unchanged.

9. Processing Arrays Using Nested Loops

Nested loops are commonly used to process two-dimensional arrays. The outer loop usually iterates through rows, while the inner loop iterates through the columns of the current row.

General Syntax

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        // Process array[i][j]
    }
}

The expression array.length gives the number of rows. The expression array[i].length gives the number of elements in row i.

Example: Displaying Every Element

public class DisplayMatrix {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Output:

1 2 3
4 5 6
7 8 9

The outer loop selects a row. The inner loop prints all elements in that row. The println() statement moves the output to a new line after each row.

10. Processing with Enhanced for Loops

Enhanced for loops can simplify reading the elements of a two-dimensional array when you do not need explicit indexes.

public class EnhancedLoopMatrix {
    public static void main(String[] args) {
        int[][] matrix = {
            {10, 20},
            {30, 40},
            {50, 60}
        };

        for (int[] row : matrix) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

Output:

10 20
30 40
50 60

The outer loop retrieves each row array, and the inner loop reads its values. Enhanced loops are convenient for traversal, while indexed loops are often better when updating elements by position.

11. Calculating the Sum of All Elements

A common operation is to calculate the sum of every value stored in a two-dimensional array. Initialize a variable to zero and add each element during traversal.

public class MatrixSum {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        int sum = 0;

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                sum += matrix[i][j];
            }
        }

        System.out.println("Total sum: " + sum);
    }
}

Output:

Total sum: 45

This operation is useful for calculating totals in financial reports, inventory systems, and numerical applications.

12. Calculating Row Sums

A row sum is the total of all values within a single row. Reset the sum variable at the beginning of each outer-loop iteration.

public class RowSums {
    public static void main(String[] args) {
        int[][] marks = {
            {70, 80, 90},
            {60, 75, 85},
            {88, 92, 95}
        };

        for (int i = 0; i < marks.length; i++) {
            int rowSum = 0;

            for (int j = 0; j < marks[i].length; j++) {
                rowSum += marks[i][j];
            }

            System.out.println("Row " + i + " sum: " + rowSum);
        }
    }
}

Output:

Row 0 sum: 240
Row 1 sum: 220
Row 2 sum: 275

The rowSum variable is initialized inside the outer loop so that each row has its own independent total.

13. Calculating Column Sums

A column sum adds the values at the same column position across multiple rows. For a rectangular array, the number of columns can be obtained from the first row, provided the array contains at least one row.

public class ColumnSums {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        if (matrix.length > 0) {
            for (int j = 0; j < matrix[0].length; j++) {
                int columnSum = 0;

                for (int i = 0; i < matrix.length; i++) {
                    columnSum += matrix[i][j];
                }

                System.out.println(
                    "Column " + j + " sum: " + columnSum
                );
            }
        }
    }
}

Output:

Column 0 sum: 12
Column 1 sum: 15
Column 2 sum: 18

This example assumes a rectangular array with rows of equal length. For a jagged array, column-processing logic must account for rows that may not contain the requested column.

14. Searching for an Element

Searching means locating a specific value in the array. Nested loops can examine each element until the target is found.

public class SearchMatrix {
    public static void main(String[] args) {
        int[][] numbers = {
            {10, 20, 30},
            {40, 50, 60},
            {70, 80, 90}
        };

        int target = 50;
        boolean found = false;

        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < numbers[i].length; j++) {
                if (numbers[i][j] == target) {
                    System.out.println(
                        "Found at row " + i + ", column " + j
                    );
                    found = true;
                    break;
                }
            }

            if (found) {
                break;
            }
        }

        if (!found) {
            System.out.println("Element not found.");
        }
    }
}

Output:

Found at row 1, column 1

The Boolean variable records whether the target was found. The two break statements stop both loops once a match is located.

15. Updating Elements with Conditions

You can process a two-dimensional array and update only those elements that satisfy a condition. This is useful for applying discounts, adjusting marks, or normalizing numerical values.

public class ConditionalMatrixUpdate {
    public static void main(String[] args) {
        int[][] values = {
            {5, 15, 25},
            {10, 20, 30}
        };

        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < values[i].length; j++) {
                if (values[i][j] < 20) {
                    values[i][j] += 5;
                }
            }
        }

        for (int[] row : values) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

Output:

10 20 25
15 20 30

Every element below 20 is increased by five. Values that do not meet the condition remain unchanged.

16. Rectangular and Jagged Arrays

Java supports arrays whose rows have different lengths. These are known as jagged arrays. A rectangular array has the same number of columns in every row, while a jagged array may have a different number of elements in each row.

16.1 Rectangular Array

int[][] rectangular = new int[3][4];

This array contains three rows, each with four integer elements.

16.2 Jagged Array

int[][] jagged = new int[3][];

jagged[0] = new int[2];
jagged[1] = new int[4];
jagged[2] = new int[3];

The first row contains two elements, the second contains four, and the third contains three.

Example: Processing a Jagged Array

public class JaggedArrayExample {
    public static void main(String[] args) {
        int[][] data = {
            {10, 20},
            {30, 40, 50},
            {60}
        };

        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                System.out.print(data[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Output:

10 20
30 40 50
60

Always use data[i].length to determine the number of elements in the current row. Do not assume that every row has the same length unless the program guarantees it.

17. Working with Matrix Diagonals

In a square matrix, the main diagonal contains elements where the row index equals the column index. The secondary diagonal runs from the top-right corner to the bottom-left corner.

Example: Main Diagonal Sum

public class DiagonalSum {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        int sum = 0;

        for (int i = 0; i < matrix.length; i++) {
            sum += matrix[i][i];
        }

        System.out.println("Main diagonal sum: " + sum);
    }
}

Output:

Main diagonal sum: 15

The main diagonal consists of 1, 5, and 9. This approach assumes a square matrix so that each referenced diagonal position exists.

18. Transposing a Matrix

The transpose of a matrix is formed by exchanging its rows and columns. An element at position matrix[i][j] is placed at position transpose[j][i].

public class MatrixTranspose {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };

        int rows = matrix.length;
        int columns = matrix[0].length;
        int[][] transpose = new int[columns][rows];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                transpose[j][i] = matrix[i][j];
            }
        }

        for (int[] row : transpose) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

Output:

1 4
2 5
3 6

This example assumes that the source array is non-empty and rectangular. For production code, validate those conditions before using matrix[0].length.

19. Two-Dimensional Arrays and User Input

Programs often receive matrix values from a user. The Scanner class can read the number of rows and columns, then populate the array.

import java.util.Scanner;

public class MatrixInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter number of rows: ");
        int rows = scanner.nextInt();

        System.out.print("Enter number of columns: ");
        int columns = scanner.nextInt();

        if (rows <= 0 || columns <= 0) {
            System.out.println("Rows and columns must be positive.");
            scanner.close();
            return;
        }

        int[][] matrix = new int[rows][columns];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                System.out.print(
                    "Enter value for row " + i + ", column " + j + ": "
                );
                matrix[i][j] = scanner.nextInt();
            }
        }

        System.out.println("Matrix:");

        for (int[] row : matrix) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }

        scanner.close();
    }
}

This program creates an array based on the supplied dimensions, reads each value, and prints the resulting matrix. It checks that the dimensions are positive before allocating the array. For real applications, input parsing and unusually large dimensions may also need validation.

20. Common Errors and Troubleshooting

21. Best Practices for Processing Two-Dimensional Arrays

• Use descriptive names such as studentMarks, salesData, or matrix.
• Use nested loops when processing rows and columns.
• Use array[i].length when traversing a row.
• Validate indexes when their values are supplied externally.
• Initialize every row before attempting to access its elements.
• Keep row totals, column totals, and overall totals in appropriately scoped variables.
• Use enhanced for loops when you only need to read values and do not need indexes.
• Check whether an array is empty before accessing its first row.
• Consider jagged arrays when rows naturally contain different numbers of values.
• Choose data structures that fit the problem instead of using a matrix when the data is not naturally tabular.

22. Practice Exercises

1. Create a Matrix: Create a 3 × 3 integer array and initialize it with nine values.
2. Display a Matrix: Use nested loops to print each row on a separate line.
3. Update Elements: Replace the element at row 1, column 2 with 100.
4. Calculate Total: Find the sum of every element in a 3 × 4 array.
5. Row Totals: Calculate and display the sum of each row.
6. Column Totals: Calculate the sum of each column in a rectangular matrix.
7. Search a Value: Search for a target number and print its row and column indexes.
8. Conditional Update: Increase every even element by 10.
9. Main Diagonal: Calculate the sum of the main diagonal of a square matrix.
10. Transpose: Create and print the transpose of a rectangular matrix.
11. Jagged Array: Create rows of different lengths and display every element.
12. User Input: Read matrix dimensions and values using Scanner.

23. Mini Project: Student Marks Analysis System

Objective: Build a small Java program that stores marks for multiple students across several subjects and calculates each student's total marks.

Requirements

• Store student marks in a two-dimensional integer array.
• Represent each student as a row and each subject as a column.
• Display the marks in a tabular format.
• Calculate the total marks for every student.
• Calculate the total marks for each subject.
• Identify the student with the highest total.

Sample Implementation

public class StudentMarksAnalysis {
    public static void main(String[] args) {
        int[][] marks = {
            {80, 75, 90},
            {65, 85, 70},
            {95, 92, 88},
            {72, 78, 81}
        };

        int highestTotal = Integer.MIN_VALUE;
        int topStudent = -1;

        System.out.println("Student Marks:");

        for (int i = 0; i < marks.length; i++) {
            int total = 0;

            for (int j = 0; j < marks[i].length; j++) {
                System.out.print(marks[i][j] + " ");
                total += marks[i][j];
            }

            System.out.println("| Total: " + total);

            if (total > highestTotal) {
                highestTotal = total;
                topStudent = i;
            }
        }

        System.out.println(
            "Top student: " + (topStudent + 1)
        );
        System.out.println("Highest total: " + highestTotal);
    }
}

Output:

Student Marks:
80 75 90 | Total: 245
65 85 70 | Total: 220
95 92 88 | Total: 275
72 78 81 | Total: 231
Top student: 3
Highest total: 275

This project demonstrates two-dimensional array creation, nested-loop traversal, row calculations, and conditional comparisons. You can extend it by adding user input, average calculations, grade assignment, and subject-wise rankings.

24. Interview Questions and Answers

Q1. What is a two-dimensional array in Java?

A two-dimensional array is an array whose elements are themselves arrays. It is commonly used to represent rows and columns of data.

Q2. How do you declare a two-dimensional array?

Use a declaration such as int[][] matrix;.

Q3. How do you create a 3 × 4 integer array?

Use int[][] matrix = new int[3][4];.

Q4. How do you access an element?

Use matrix[rowIndex][columnIndex].

Q5. What does matrix.length return?

It returns the number of rows in the outer array.

Q6. What does matrix[i].length return?

It returns the number of elements in row i.

Q7. Why are nested loops used with two-dimensional arrays?

The outer loop processes rows, and the inner loop processes the elements within each row.

Q8. What is a jagged array?

A jagged array is a two-dimensional array in which different rows can have different lengths.

Q9. How do you update a particular element?

Use an assignment such as matrix[1][2] = 100;.

Q10. How can you calculate the sum of all elements?

Initialize a sum variable to zero and add each element while traversing the array with nested loops.

Q11. What is a matrix transpose?

A transpose exchanges the rows and columns of a matrix. For an element at [i][j], the corresponding transposed position is [j][i].

Q12. What can cause a NullPointerException with a two-dimensional array?

It can occur when a row reference is null and the program attempts to access an element through that row.

25. Quick Revision Checklist

• A two-dimensional array organizes values into rows and columns.
• Declare an array using dataType[][] arrayName;.
• Create an array using new dataType[rows][columns].
• Initialize values using nested array initializers or assignments.
• Access an element using array[row][column].
• Use nested loops to process every element.
• array.length gives the number of rows.
• array[i].length gives the length of a particular row.
• Java supports both rectangular and jagged arrays.
• Validate indexes and initialize rows before accessing elements.
• Practice sums, searches, conditional updates, and matrix transposition.

26. Conclusion

Creating and processing two-dimensional arrays is an important Core Java skill for working with structured data. Understanding declarations, initialization, row and column indexes, nested loops, and array traversal makes it easier to solve problems involving matrices, student marks, sales reports, and inventory tables. Practicing searches, calculations, conditional updates, and transposition will strengthen your programming fundamentals and prepare you for more advanced Java concepts.

Continue learning with the JustAcademy Core Java Training Course. You can also register for a demo session or visit the JustAcademy homepage for more learning resources.